home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 22 / CU Amiga Magazine's Super CD-ROM 22 (1998)(EMAP Images)(GB)[!][issue 1998-05].iso / PowerPC / Programming / PPCSmallEiffel / bin_c / pretty9.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  38.3 KB  |  1,226 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "pretty.h"
  9. /*No:FIXED_ARRAY[MANIFEST_STRING].storage*/
  10. /*No:FIXED_ARRAY[MANIFEST_STRING].capacity*/
  11. void r256with_capacity(T256* C,int a1){
  12. /*IF*/if (((((T256*)C))->_capacity/*4*/)<(a1)) {
  13. C->_storage=calloc(a1,sizeof(T0*));
  14. C->_capacity=a1;
  15. }
  16. /*FI*/C->_upper=-(1);
  17. }
  18. /*No:FIXED_ARRAY[MANIFEST_STRING].put*/
  19. /*No:FIXED_ARRAY[MANIFEST_STRING].upper*/
  20. void r256add_last(T256* C,T0* a1){
  21. int _new_capacity=0;
  22. /*IF*/if ((((((T256*)C))->_upper/*8*/)+(1))<=(((((T256*)C))->_capacity/*4*/)-(1))) {
  23. C->_upper=((((T256*)C))->_upper/*8*/)+(1);
  24. }
  25.  else if (((((T256*)C))->_capacity/*4*/)==(0)) {
  26. C->_storage=calloc(2,sizeof(T0*));
  27. C->_capacity=2;
  28. C->_upper=0;
  29. }
  30. else {
  31. _new_capacity=(2)*((((T256*)C))->_capacity/*4*/);
  32. C->_storage=r729realloc((((T256*)C))->_storage/*0*/,(((T256*)C))->_capacity/*4*/,_new_capacity);
  33. C->_capacity=_new_capacity;
  34. C->_upper=((((T256*)C))->_upper/*8*/)+(1);
  35. }
  36. /*FI*//*[IRF3.5put*/((((T256*)C))->_storage/*0*/)[(((T256*)C))->_upper/*8*/]=(a1);
  37. /*]*/
  38. }
  39. /*No:FIXED_ARRAY[RUN_CLASS].storage*/
  40. /*No:FIXED_ARRAY[RUN_CLASS].capacity*/
  41. void r187with_capacity(T187* C,int a1){
  42. /*IF*/if (((((T187*)C))->_capacity/*4*/)<(a1)) {
  43. C->_storage=calloc(a1,sizeof(T0*));
  44. C->_capacity=a1;
  45. }
  46. /*FI*/C->_upper=-(1);
  47. }
  48. int r187fast_index_of(T187* C,T0* a1){
  49. int R=0;
  50. R=r659fast_index_of((((T187*)C))->_storage/*0*/,a1,(((T187*)C))->_upper/*8*/);
  51. return R;
  52. }
  53. /*No:FIXED_ARRAY[RUN_CLASS].put*/
  54. /*No:FIXED_ARRAY[RUN_CLASS].upper*/
  55. void r187add_last(T187* C,T0* a1){
  56. int _new_capacity=0;
  57. /*IF*/if ((((((T187*)C))->_upper/*8*/)+(1))<=(((((T187*)C))->_capacity/*4*/)-(1))) {
  58. C->_upper=((((T187*)C))->_upper/*8*/)+(1);
  59. }
  60.  else if (((((T187*)C))->_capacity/*4*/)==(0)) {
  61. C->_storage=calloc(2,sizeof(T0*));
  62. C->_capacity=2;
  63. C->_upper=0;
  64. }
  65. else {
  66. _new_capacity=(2)*((((T187*)C))->_capacity/*4*/);
  67. C->_storage=r659realloc((((T187*)C))->_storage/*0*/,(((T187*)C))->_capacity/*4*/,_new_capacity);
  68. C->_capacity=_new_capacity;
  69. C->_upper=((((T187*)C))->_upper/*8*/)+(1);
  70. }
  71. /*FI*//*[IRF3.5put*/((((T187*)C))->_storage/*0*/)[(((T187*)C))->_upper/*8*/]=(a1);
  72. /*]*/
  73. }
  74. T0* r419item(T419* C,int a1){
  75. T0* R=NULL;
  76. R=((((T419*)C))->_storage/*0*/)[(a1)-((((T419*)C))->_lower/*12*/)];
  77. return R;
  78. }
  79. /*No:ARRAY[INSTRUCTION].storage*/
  80. T0* r419twin(T419* C){
  81. T0* R=NULL;
  82. R=malloc(sizeof(*C));
  83. *((T419*)R)=M419;
  84. r419copy(((T419*)R),((T0*)C));
  85. return R;
  86. }
  87. /*No:ARRAY[INSTRUCTION].capacity*/
  88. void r419copy(T419* C,T0* a1){
  89. int _needed_capacity=0;
  90. C->_lower=(((T419*)((T419*)a1)))->_lower/*12*/;
  91. C->_upper=(((T419*)((T419*)a1)))->_upper/*8*/;
  92. _needed_capacity=(((((T419*)C))->_upper/*8*/)-((((T419*)C))->_lower/*12*/))+(1);
  93. /*IF*/if (((((T419*)C))->_capacity/*4*/)<(_needed_capacity)) {
  94. C->_capacity=_needed_capacity;
  95. C->_storage=calloc((((T419*)C))->_capacity/*4*/,sizeof(T0*));
  96. }
  97. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  98. r705copy_from((((T419*)C))->_storage/*0*/,(((T419*)((T419*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  99. }
  100. /*FI*/}
  101. /*No:ARRAY[INSTRUCTION].lower*/
  102. /*No:ARRAY[INSTRUCTION].put*/
  103. /*No:ARRAY[INSTRUCTION].upper*/
  104. int r419count(T419* C){
  105. int R=0;
  106. R=(((((T419*)C))->_upper/*8*/)-((((T419*)C))->_lower/*12*/))+(1);
  107. return R;
  108. }
  109. void r419add_last(T419* C,T0* a1){
  110. int _new_capacity=0;
  111. /*IF*/if (((((T419*)C))->_capacity/*4*/)<((r419count(C))+(1))) {
  112. /*IF*/if (((((T419*)C))->_capacity/*4*/)==(0)) {
  113. C->_capacity=16;
  114. C->_storage=calloc((((T419*)C))->_capacity/*4*/,sizeof(T0*));
  115. }
  116. else {
  117. _new_capacity=(2)*((((T419*)C))->_capacity/*4*/);
  118. C->_storage=r705realloc((((T419*)C))->_storage/*0*/,(((T419*)C))->_capacity/*4*/,_new_capacity);
  119. C->_capacity=_new_capacity;
  120. }
  121. /*FI*/}
  122. /*FI*/C->_upper=((((T419*)C))->_upper/*8*/)+(1);
  123. /*[IRF3.6put*/{T419* C1=C;
  124. T0* b1=a1;
  125. int b2=(((T419*)C))->_upper/*8*/;
  126. ((((T419*)C1))->_storage/*0*/)[(b2)-((((T419*)C1))->_lower/*12*/)]=(b1);
  127. }/*]*/
  128. }
  129. T0* r901item(T901* C,int a1){
  130. T0* R=NULL;
  131. R=((((T901*)C))->_storage/*0*/)[(a1)-((((T901*)C))->_lower/*12*/)];
  132. return R;
  133. }
  134. /*No:ARRAY[CLASS_NAME].storage*/
  135. T0* r901twin(T901* C){
  136. T0* R=NULL;
  137. R=malloc(sizeof(*C));
  138. *((T901*)R)=M901;
  139. r901copy(((T901*)R),((T0*)C));
  140. return R;
  141. }
  142. /*No:ARRAY[CLASS_NAME].capacity*/
  143. void r901copy(T901* C,T0* a1){
  144. int _needed_capacity=0;
  145. C->_lower=(((T901*)((T901*)a1)))->_lower/*12*/;
  146. C->_upper=(((T901*)((T901*)a1)))->_upper/*8*/;
  147. _needed_capacity=(((((T901*)C))->_upper/*8*/)-((((T901*)C))->_lower/*12*/))+(1);
  148. /*IF*/if (((((T901*)C))->_capacity/*4*/)<(_needed_capacity)) {
  149. C->_capacity=_needed_capacity;
  150. C->_storage=calloc((((T901*)C))->_capacity/*4*/,sizeof(T0*));
  151. }
  152. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  153. r221copy_from((((T901*)C))->_storage/*0*/,(((T901*)((T901*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  154. }
  155. /*FI*/}
  156. /*No:ARRAY[CLASS_NAME].lower*/
  157. /*No:ARRAY[CLASS_NAME].put*/
  158. /*No:ARRAY[CLASS_NAME].upper*/
  159. int r901count(T901* C){
  160. int R=0;
  161. R=(((((T901*)C))->_upper/*8*/)-((((T901*)C))->_lower/*12*/))+(1);
  162. return R;
  163. }
  164. void r901add_last(T901* C,T0* a1){
  165. int _new_capacity=0;
  166. /*IF*/if (((((T901*)C))->_capacity/*4*/)<((r901count(C))+(1))) {
  167. /*IF*/if (((((T901*)C))->_capacity/*4*/)==(0)) {
  168. C->_capacity=16;
  169. C->_storage=calloc((((T901*)C))->_capacity/*4*/,sizeof(T0*));
  170. }
  171. else {
  172. _new_capacity=(2)*((((T901*)C))->_capacity/*4*/);
  173. C->_storage=r221realloc((((T901*)C))->_storage/*0*/,(((T901*)C))->_capacity/*4*/,_new_capacity);
  174. C->_capacity=_new_capacity;
  175. }
  176. /*FI*/}
  177. /*FI*/C->_upper=((((T901*)C))->_upper/*8*/)+(1);
  178. /*[IRF3.6put*/{T901* C1=C;
  179. T0* b1=a1;
  180. int b2=(((T901*)C))->_upper/*8*/;
  181. ((((T901*)C1))->_storage/*0*/)[(b2)-((((T901*)C1))->_lower/*12*/)]=(b1);
  182. }/*]*/
  183. }
  184. /*No:FIXED_ARRAY[STRING].clear_all*/
  185. /*No:FIXED_ARRAY[STRING].set_all_with*/
  186. void r927make(T927* C,int a1){
  187. /*IF*/if ((a1)==(0)) {
  188. C->_upper=-(1);
  189. }
  190.  else if (((((T927*)C))->_capacity/*4*/)==(0)) {
  191. C->_storage=calloc(a1,sizeof(T0*));
  192. C->_capacity=a1;
  193. C->_upper=(a1)-(1);
  194. }
  195.  else if (((((T927*)C))->_capacity/*4*/)<(a1)) {
  196. C->_storage=calloc(a1,sizeof(T0*));
  197. C->_capacity=a1;
  198. C->_upper=(a1)-(1);
  199. }
  200. else {
  201. C->_upper=(a1)-(1);
  202. /*[IRF3.6clear_all*/{T927* C1=C;
  203. T0* __value=NULL;
  204. /*[IRF3.6set_all_with*/{T927* C2=C1;
  205. T0* c1=__value;
  206. r400set_all_with((((T927*)C2))->_storage/*0*/,c1,(((T927*)C2))->_upper/*8*/);
  207. }/*]*/
  208. }/*]*/
  209. }
  210. /*FI*/}
  211. /*No:FIXED_ARRAY[STRING].item*/
  212. /*No:FIXED_ARRAY[STRING].storage*/
  213. /*No:FIXED_ARRAY[STRING].capacity*/
  214. void r927with_capacity(T927* C,int a1){
  215. /*IF*/if (((((T927*)C))->_capacity/*4*/)<(a1)) {
  216. C->_storage=calloc(a1,sizeof(T0*));
  217. C->_capacity=a1;
  218. }
  219. /*FI*/C->_upper=-(1);
  220. }
  221. int r927fast_index_of(T927* C,T0* a1){
  222. int R=0;
  223. R=r400fast_index_of((((T927*)C))->_storage/*0*/,a1,(((T927*)C))->_upper/*8*/);
  224. return R;
  225. }
  226. /*No:FIXED_ARRAY[STRING].put*/
  227. /*No:FIXED_ARRAY[STRING].upper*/
  228. void r927add_last(T927* C,T0* a1){
  229. int _new_capacity=0;
  230. /*IF*/if ((((((T927*)C))->_upper/*8*/)+(1))<=(((((T927*)C))->_capacity/*4*/)-(1))) {
  231. C->_upper=((((T927*)C))->_upper/*8*/)+(1);
  232. }
  233.  else if (((((T927*)C))->_capacity/*4*/)==(0)) {
  234. C->_storage=calloc(2,sizeof(T0*));
  235. C->_capacity=2;
  236. C->_upper=0;
  237. }
  238. else {
  239. _new_capacity=(2)*((((T927*)C))->_capacity/*4*/);
  240. C->_storage=r400realloc((((T927*)C))->_storage/*0*/,(((T927*)C))->_capacity/*4*/,_new_capacity);
  241. C->_capacity=_new_capacity;
  242. C->_upper=((((T927*)C))->_upper/*8*/)+(1);
  243. }
  244. /*FI*//*[IRF3.5put*/((((T927*)C))->_storage/*0*/)[(((T927*)C))->_upper/*8*/]=(a1);
  245. /*]*/
  246. }
  247. /*No:ARRAY[RUN_CLASS].clear_all*/
  248. /*No:ARRAY[RUN_CLASS].set_all_with*/
  249. void r396make(T396* C,int a1,int a2){
  250. int _needed=0;
  251. C->_lower=a1;
  252. C->_upper=a2;
  253. _needed=((a2)-(a1))+(1);
  254. /*IF*/if ((_needed)>(0)) {
  255. /*IF*/if (((((T396*)C))->_capacity/*4*/)<(_needed)) {
  256. /*IF*/if (((((T396*)C))->_capacity/*4*/)==(0)) {
  257. C->_storage=calloc(_needed,sizeof(T0*));
  258. }
  259. else {
  260. C->_storage=calloc(_needed,sizeof(T0*));
  261. }
  262. /*FI*/C->_capacity=_needed;
  263. }
  264. else {
  265. /*[IRF3.6clear_all*/{T396* C1=C;
  266. T0* __value=NULL;
  267. /*[IRF3.6set_all_with*/{T396* C2=C1;
  268. T0* c1=__value;
  269. r659set_all_with((((T396*)C2))->_storage/*0*/,c1,((((T396*)C2))->_upper/*8*/)-((((T396*)C2))->_lower/*12*/));
  270. }/*]*/
  271. }/*]*/
  272. }
  273. /*FI*/}
  274. /*FI*/}
  275. int r396fast_has(T396* C,T0* a1){
  276. int R=0;
  277. /*IF*/if ((r396count(C))>(0)) {
  278. R=(r396fast_index_of(C,a1))<=((((T396*)C))->_upper/*8*/);
  279. }
  280. /*FI*/return R;
  281. }
  282. T0* r396item(T396* C,int a1){
  283. T0* R=NULL;
  284. R=((((T396*)C))->_storage/*0*/)[(a1)-((((T396*)C))->_lower/*12*/)];
  285. return R;
  286. }
  287. void r396resize(T396* C,int a1,int a2){
  288. int _mem=0;
  289. int _up=0;
  290. int _i=0;
  291. T0* _other=NULL;
  292. {T396*n=malloc(sizeof(*n));
  293. *n=M396;
  294. r396make(n,a1,a2);
  295. _other=(T0*)n;
  296. }
  297. _i=r2max((((T396*)C))->_lower/*12*/,(((T396*)((T396*)_other)))->_lower/*12*/);
  298. _up=r2min((((T396*)C))->_upper/*8*/,(((T396*)((T396*)_other)))->_upper/*8*/);
  299. while (!((_i)>(_up))) {
  300. /*[IRF3.6put*/{T396* C1=((T396*)_other);
  301. T0* b1=r396item(C,_i);
  302. int b2=_i;
  303. ((((T396*)C1))->_storage/*0*/)[(b2)-((((T396*)C1))->_lower/*12*/)]=(b1);
  304. }/*]*/
  305. _i=(_i)+(1);
  306. }
  307. *((T396*)(C))=*((T396*)(_other));
  308. }
  309. /*No:ARRAY[RUN_CLASS].storage*/
  310. /*No:ARRAY[RUN_CLASS].capacity*/
  311. /*No:ARRAY[RUN_CLASS].lower*/
  312. int r396fast_index_of(T396* C,T0* a1){
  313. int R=0;
  314. R=((((T396*)C))->_lower/*12*/)+(r659fast_index_of((((T396*)C))->_storage/*0*/,a1,((((T396*)C))->_upper/*8*/)-((((T396*)C))->_lower/*12*/)));
  315. return R;
  316. }
  317. /*No:ARRAY[RUN_CLASS].put*/
  318. /*No:ARRAY[RUN_CLASS].upper*/
  319. void r396add_last(T396* C,T0* a1){
  320. int _new_capacity=0;
  321. /*IF*/if (((((T396*)C))->_capacity/*4*/)<((r396count(C))+(1))) {
  322. /*IF*/if (((((T396*)C))->_capacity/*4*/)==(0)) {
  323. C->_capacity=16;
  324. C->_storage=calloc((((T396*)C))->_capacity/*4*/,sizeof(T0*));
  325. }
  326. else {
  327. _new_capacity=(2)*((((T396*)C))->_capacity/*4*/);
  328. C->_storage=r659realloc((((T396*)C))->_storage/*0*/,(((T396*)C))->_capacity/*4*/,_new_capacity);
  329. C->_capacity=_new_capacity;
  330. }
  331. /*FI*/}
  332. /*FI*/C->_upper=((((T396*)C))->_upper/*8*/)+(1);
  333. /*[IRF3.6put*/{T396* C1=C;
  334. T0* b1=a1;
  335. int b2=(((T396*)C))->_upper/*8*/;
  336. ((((T396*)C1))->_storage/*0*/)[(b2)-((((T396*)C1))->_lower/*12*/)]=(b1);
  337. }/*]*/
  338. }
  339. int r396count(T396* C){
  340. int R=0;
  341. R=(((((T396*)C))->_upper/*8*/)-((((T396*)C))->_lower/*12*/))+(1);
  342. return R;
  343. }
  344. T0* r794at(T794* C,T0* a1){
  345. T0* R=NULL;
  346. int _foo=0;
  347. _foo=r794has(C,a1);
  348. R=r52item(((T52*)((((T794*)C))->_store/*4*/)),(((T794*)C))->_has_mem/*24*/);
  349. return R;
  350. }
  351. void r794expand(T794* C){
  352. int _old_size=0;
  353. int _i=0;
  354. C->_item_mem=0;
  355. _old_size=r52count(((T52*)((((T794*)C))->_store/*4*/)));
  356. r429resize(((T429*)((((T794*)C))->_chain/*12*/)),1,(2)*(_old_size));
  357. r52resize(((T52*)((((T794*)C))->_keys/*0*/)),1,(2)*(_old_size));
  358. r52resize(((T52*)((((T794*)C))->_store/*4*/)),1,(2)*(_old_size));
  359. _i=(_old_size)+(1);
  360. while (!((_i)==(r429count(((T429*)((((T794*)C))->_chain/*12*/)))))) {
  361. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  362. int b1=(_i)+(1);
  363. int b2=_i;
  364. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  365. }/*]*/
  366. _i=(_i)+(1);
  367. }
  368. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  369. int b1=(((T794*)C))->_free/*16*/;
  370. int b2=_i;
  371. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  372. }/*]*/
  373. C->_free=(_old_size)+(1);
  374. }
  375. T0*oBC672tmp_buckets=NULL;
  376. /*No:DICTIONARY[STRING,STRING].free*/
  377. void r794make(T794* C){
  378. C->_modulus=(2)*(32);
  379. {T226*n=malloc(sizeof(*n));
  380. *n=M226;
  381. r226make(n,(((T794*)C))->_modulus/*20*/);
  382. C->_buckets=(T0*)n;
  383. }
  384. {T429*n=malloc(sizeof(*n));
  385. *n=M429;
  386. r429make(n,1,32);
  387. C->_chain=(T0*)n;
  388. }
  389. {T52*n=malloc(sizeof(*n));
  390. *n=M52;
  391. r52make(n,1,32);
  392. C->_store=(T0*)n;
  393. }
  394. {T52*n=malloc(sizeof(*n));
  395. *n=M52;
  396. r52make(n,1,32);
  397. C->_keys=(T0*)n;
  398. }
  399. r794initialize(C);
  400. }
  401. void r794resize(T794* C,int a1){
  402. int _p=0;
  403. int _n=0;
  404. int _i=0;
  405. int _hash=0;
  406. r226copy(((T226*)(oBC672tmp_buckets)),(((T794*)C))->_buckets/*8*/);
  407. r226make(((T226*)((((T794*)C))->_buckets/*8*/)),a1);
  408. _i=0;
  409. while (!((_i)>=((((T794*)C))->_modulus/*20*/))) {
  410. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  411. while (!((_n)==(0))) {
  412. _p=r429item(((T429*)((((T794*)C))->_chain/*12*/)),_n);
  413. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T794*)C))->_keys/*0*/)),_n)))))%(a1);
  414. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  415. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  416. int b2=_n;
  417. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  418. }/*]*/
  419. /*[IRF3.5put*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  420. /*]*/
  421. _n=_p;
  422. }
  423. _i=(_i)+(1);
  424. }
  425. C->_modulus=a1;
  426. C->_item_mem=0;
  427. }
  428. /*No:DICTIONARY[STRING,STRING].item_mem*/
  429. /*No:DICTIONARY[STRING,STRING].chain*/
  430. /*No:DICTIONARY[STRING,STRING].keys*/
  431. /*No:DICTIONARY[STRING,STRING].buckets*/
  432. int r794has(T794* C,T0* a1){
  433. int R=0;
  434. /*IF*/if ((((((T794*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  435. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T794*)C))->_modulus/*20*/)]/*)*/;
  436. while (!((((((T794*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  437. C->_has_mem=r429item(((T429*)((((T794*)C))->_chain/*12*/)),(((T794*)C))->_has_mem/*24*/);
  438. }
  439. }
  440. /*FI*/R=((((T794*)C))->_has_mem/*24*/)!=(0);
  441. return R;
  442. }
  443. /*No:DICTIONARY[STRING,STRING].Min_size*/
  444. /*No:DICTIONARY[STRING,STRING].store*/
  445. void r794with_capacity(T794* C,int a1){
  446. int _i=0;
  447. _i=32;
  448. while (!((_i)>=(a1))) {
  449. _i=(2)*(_i);
  450. }
  451. C->_modulus=(2)*(_i);
  452. {T226*n=malloc(sizeof(*n));
  453. *n=M226;
  454. r226make(n,(((T794*)C))->_modulus/*20*/);
  455. C->_buckets=(T0*)n;
  456. }
  457. {T429*n=malloc(sizeof(*n));
  458. *n=M429;
  459. r429make(n,1,_i);
  460. C->_chain=(T0*)n;
  461. }
  462. {T52*n=malloc(sizeof(*n));
  463. *n=M52;
  464. r52make(n,1,_i);
  465. C->_store=(T0*)n;
  466. }
  467. {T52*n=malloc(sizeof(*n));
  468. *n=M52;
  469. r52make(n,1,_i);
  470. C->_keys=(T0*)n;
  471. }
  472. r794initialize(C);
  473. }
  474. void r794put(T794* C,T0* a1,T0* a2){
  475. int _hash=0;
  476. _hash=(r7hash_code(((T7*)a2)))%((((T794*)C))->_modulus/*20*/);
  477. /*IF*/if ((((((T794*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  478. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  479. while (!((((((T794*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  480. C->_has_mem=r429item(((T429*)((((T794*)C))->_chain/*12*/)),(((T794*)C))->_has_mem/*24*/);
  481. }
  482. /*IF*/if (((((T794*)C))->_has_mem/*24*/)==(0)) {
  483. /*IF*/if (((((T794*)C))->_count/*32*/)>=(r52count(((T52*)((((T794*)C))->_store/*4*/))))) {
  484. r794expand(C);
  485. }
  486. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T794*)C))->_keys/*0*/));
  487. T0* b1=a2;
  488. int b2=(((T794*)C))->_free/*16*/;
  489. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  490. }/*]*/
  491. /*[IRF3.6put*/{T52* C1=((T52*)((((T794*)C))->_store/*4*/));
  492. T0* b1=a1;
  493. int b2=(((T794*)C))->_free/*16*/;
  494. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  495. }/*]*/
  496. C->_has_mem=(((T794*)C))->_free/*16*/;
  497. C->_free=r429item(((T429*)((((T794*)C))->_chain/*12*/)),(((T794*)C))->_free/*16*/);
  498. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  499. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  500. int b2=(((T794*)C))->_has_mem/*24*/;
  501. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  502. }/*]*/
  503. /*[IRF3.5put*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T794*)C))->_has_mem/*24*/);
  504. /*]*/
  505. C->_count=((((T794*)C))->_count/*32*/)+(1);
  506. /*IF*/if (((((T794*)C))->_count/*32*/)>(((((T794*)C))->_modulus/*20*/)*(2))) {
  507. r794resize(C,(2)*((((T794*)C))->_modulus/*20*/));
  508. }
  509. /*FI*/}
  510. /*FI*/}
  511. else {
  512. /*[IRF3.6put*/{T52* C1=((T52*)((((T794*)C))->_store/*4*/));
  513. T0* b1=a1;
  514. int b2=(((T794*)C))->_has_mem/*24*/;
  515. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  516. }/*]*/
  517. }
  518. /*FI*/C->_item_mem=0;
  519. }
  520. /*No:DICTIONARY[STRING,STRING].modulus*/
  521. /*No:DICTIONARY[STRING,STRING].count*/
  522. /*No:DICTIONARY[STRING,STRING].has_mem*/
  523. void r794initialize(T794* C){
  524. int _i=0;
  525. C->_count=0;
  526. C->_free=1;
  527. C->_has_mem=0;
  528. C->_item_mem=0;
  529. _i=1;
  530. while (!((_i)==(r429count(((T429*)((((T794*)C))->_chain/*12*/)))))) {
  531. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  532. int b1=(_i)+(1);
  533. int b2=_i;
  534. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  535. }/*]*/
  536. _i=(_i)+(1);
  537. }
  538. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  539. int b1=0;
  540. int b2=_i;
  541. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  542. }/*]*/
  543. _i=0;
  544. while (!((_i)>=((((T794*)C))->_modulus/*20*/))) {
  545. /*[IRF3.5put*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  546. /*]*/
  547. _i=(_i)+(1);
  548. }
  549. }
  550. T0* r338at(T338* C,T0* a1){
  551. T0* R=NULL;
  552. int _foo=0;
  553. _foo=r338has(C,a1);
  554. R=r956item(((T956*)((((T338*)C))->_store/*4*/)),(((T338*)C))->_has_mem/*24*/);
  555. return R;
  556. }
  557. void r338expand(T338* C){
  558. int _old_size=0;
  559. int _i=0;
  560. C->_item_mem=0;
  561. _old_size=r956count(((T956*)((((T338*)C))->_store/*4*/)));
  562. r429resize(((T429*)((((T338*)C))->_chain/*12*/)),1,(2)*(_old_size));
  563. r52resize(((T52*)((((T338*)C))->_keys/*0*/)),1,(2)*(_old_size));
  564. r956resize(((T956*)((((T338*)C))->_store/*4*/)),1,(2)*(_old_size));
  565. _i=(_old_size)+(1);
  566. while (!((_i)==(r429count(((T429*)((((T338*)C))->_chain/*12*/)))))) {
  567. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  568. int b1=(_i)+(1);
  569. int b2=_i;
  570. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  571. }/*]*/
  572. _i=(_i)+(1);
  573. }
  574. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  575. int b1=(((T338*)C))->_free/*16*/;
  576. int b2=_i;
  577. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  578. }/*]*/
  579. C->_free=(_old_size)+(1);
  580. }
  581. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].free*/
  582. void r338make(T338* C){
  583. C->_modulus=(2)*(32);
  584. {T226*n=malloc(sizeof(*n));
  585. *n=M226;
  586. r226make(n,(((T338*)C))->_modulus/*20*/);
  587. C->_buckets=(T0*)n;
  588. }
  589. {T429*n=malloc(sizeof(*n));
  590. *n=M429;
  591. r429make(n,1,32);
  592. C->_chain=(T0*)n;
  593. }
  594. {T956*n=malloc(sizeof(*n));
  595. *n=M956;
  596. r956make(n,1,32);
  597. C->_store=(T0*)n;
  598. }
  599. {T52*n=malloc(sizeof(*n));
  600. *n=M52;
  601. r52make(n,1,32);
  602. C->_keys=(T0*)n;
  603. }
  604. r338initialize(C);
  605. }
  606. void r338resize(T338* C,int a1){
  607. int _p=0;
  608. int _n=0;
  609. int _i=0;
  610. int _hash=0;
  611. r226copy(((T226*)(oBC672tmp_buckets)),(((T338*)C))->_buckets/*8*/);
  612. r226make(((T226*)((((T338*)C))->_buckets/*8*/)),a1);
  613. _i=0;
  614. while (!((_i)>=((((T338*)C))->_modulus/*20*/))) {
  615. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  616. while (!((_n)==(0))) {
  617. _p=r429item(((T429*)((((T338*)C))->_chain/*12*/)),_n);
  618. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T338*)C))->_keys/*0*/)),_n)))))%(a1);
  619. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  620. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  621. int b2=_n;
  622. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  623. }/*]*/
  624. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  625. /*]*/
  626. _n=_p;
  627. }
  628. _i=(_i)+(1);
  629. }
  630. C->_modulus=a1;
  631. C->_item_mem=0;
  632. }
  633. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].item_mem*/
  634. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].chain*/
  635. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].keys*/
  636. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].buckets*/
  637. int r338has(T338* C,T0* a1){
  638. int R=0;
  639. /*IF*/if ((((((T338*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  640. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T338*)C))->_modulus/*20*/)]/*)*/;
  641. while (!((((((T338*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  642. C->_has_mem=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_has_mem/*24*/);
  643. }
  644. }
  645. /*FI*/R=((((T338*)C))->_has_mem/*24*/)!=(0);
  646. return R;
  647. }
  648. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].Min_size*/
  649. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].store*/
  650. void r338put(T338* C,T0* a1,T0* a2){
  651. int _hash=0;
  652. _hash=(r7hash_code(((T7*)a2)))%((((T338*)C))->_modulus/*20*/);
  653. /*IF*/if ((((((T338*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  654. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  655. while (!((((((T338*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  656. C->_has_mem=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_has_mem/*24*/);
  657. }
  658. /*IF*/if (((((T338*)C))->_has_mem/*24*/)==(0)) {
  659. /*IF*/if (((((T338*)C))->_count/*32*/)>=(r956count(((T956*)((((T338*)C))->_store/*4*/))))) {
  660. r338expand(C);
  661. }
  662. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T338*)C))->_keys/*0*/));
  663. T0* b1=a2;
  664. int b2=(((T338*)C))->_free/*16*/;
  665. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  666. }/*]*/
  667. /*[IRF3.6put*/{T956* C1=((T956*)((((T338*)C))->_store/*4*/));
  668. T0* b1=a1;
  669. int b2=(((T338*)C))->_free/*16*/;
  670. ((((T956*)C1))->_storage/*0*/)[(b2)-((((T956*)C1))->_lower/*12*/)]=(b1);
  671. }/*]*/
  672. C->_has_mem=(((T338*)C))->_free/*16*/;
  673. C->_free=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_free/*16*/);
  674. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  675. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  676. int b2=(((T338*)C))->_has_mem/*24*/;
  677. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  678. }/*]*/
  679. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T338*)C))->_has_mem/*24*/);
  680. /*]*/
  681. C->_count=((((T338*)C))->_count/*32*/)+(1);
  682. /*IF*/if (((((T338*)C))->_count/*32*/)>(((((T338*)C))->_modulus/*20*/)*(2))) {
  683. r338resize(C,(2)*((((T338*)C))->_modulus/*20*/));
  684. }
  685. /*FI*/}
  686. /*FI*/}
  687. else {
  688. /*[IRF3.6put*/{T956* C1=((T956*)((((T338*)C))->_store/*4*/));
  689. T0* b1=a1;
  690. int b2=(((T338*)C))->_has_mem/*24*/;
  691. ((((T956*)C1))->_storage/*0*/)[(b2)-((((T956*)C1))->_lower/*12*/)]=(b1);
  692. }/*]*/
  693. }
  694. /*FI*/C->_item_mem=0;
  695. }
  696. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].modulus*/
  697. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].count*/
  698. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].has_mem*/
  699. void r338initialize(T338* C){
  700. int _i=0;
  701. C->_count=0;
  702. C->_free=1;
  703. C->_has_mem=0;
  704. C->_item_mem=0;
  705. _i=1;
  706. while (!((_i)==(r429count(((T429*)((((T338*)C))->_chain/*12*/)))))) {
  707. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  708. int b1=(_i)+(1);
  709. int b2=_i;
  710. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  711. }/*]*/
  712. _i=(_i)+(1);
  713. }
  714. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  715. int b1=0;
  716. int b2=_i;
  717. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  718. }/*]*/
  719. _i=0;
  720. while (!((_i)>=((((T338*)C))->_modulus/*20*/))) {
  721. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  722. /*]*/
  723. _i=(_i)+(1);
  724. }
  725. }
  726. T0* r199at(T199* C,T0* a1){
  727. T0* R=NULL;
  728. int _foo=0;
  729. _foo=r199has(C,a1);
  730. R=r477item(((T477*)((((T199*)C))->_store/*4*/)),(((T199*)C))->_has_mem/*24*/);
  731. return R;
  732. }
  733. void r199expand(T199* C){
  734. int _old_size=0;
  735. int _i=0;
  736. C->_item_mem=0;
  737. _old_size=r477count(((T477*)((((T199*)C))->_store/*4*/)));
  738. r429resize(((T429*)((((T199*)C))->_chain/*12*/)),1,(2)*(_old_size));
  739. r52resize(((T52*)((((T199*)C))->_keys/*0*/)),1,(2)*(_old_size));
  740. r477resize(((T477*)((((T199*)C))->_store/*4*/)),1,(2)*(_old_size));
  741. _i=(_old_size)+(1);
  742. while (!((_i)==(r429count(((T429*)((((T199*)C))->_chain/*12*/)))))) {
  743. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  744. int b1=(_i)+(1);
  745. int b2=_i;
  746. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  747. }/*]*/
  748. _i=(_i)+(1);
  749. }
  750. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  751. int b1=(((T199*)C))->_free/*16*/;
  752. int b2=_i;
  753. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  754. }/*]*/
  755. C->_free=(_old_size)+(1);
  756. }
  757. /*No:DICTIONARY[RUN_FEATURE,STRING].free*/
  758. void r199make(T199* C){
  759. C->_modulus=(2)*(32);
  760. {T226*n=malloc(sizeof(*n));
  761. *n=M226;
  762. r226make(n,(((T199*)C))->_modulus/*20*/);
  763. C->_buckets=(T0*)n;
  764. }
  765. {T429*n=malloc(sizeof(*n));
  766. *n=M429;
  767. r429make(n,1,32);
  768. C->_chain=(T0*)n;
  769. }
  770. {T477*n=malloc(sizeof(*n));
  771. *n=M477;
  772. r477make(n,1,32);
  773. C->_store=(T0*)n;
  774. }
  775. {T52*n=malloc(sizeof(*n));
  776. *n=M52;
  777. r52make(n,1,32);
  778. C->_keys=(T0*)n;
  779. }
  780. r199initialize(C);
  781. }
  782. void r199resize(T199* C,int a1){
  783. int _p=0;
  784. int _n=0;
  785. int _i=0;
  786. int _hash=0;
  787. r226copy(((T226*)(oBC672tmp_buckets)),(((T199*)C))->_buckets/*8*/);
  788. r226make(((T226*)((((T199*)C))->_buckets/*8*/)),a1);
  789. _i=0;
  790. while (!((_i)>=((((T199*)C))->_modulus/*20*/))) {
  791. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  792. while (!((_n)==(0))) {
  793. _p=r429item(((T429*)((((T199*)C))->_chain/*12*/)),_n);
  794. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T199*)C))->_keys/*0*/)),_n)))))%(a1);
  795. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  796. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  797. int b2=_n;
  798. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  799. }/*]*/
  800. /*[IRF3.5put*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  801. /*]*/
  802. _n=_p;
  803. }
  804. _i=(_i)+(1);
  805. }
  806. C->_modulus=a1;
  807. C->_item_mem=0;
  808. }
  809. /*No:DICTIONARY[RUN_FEATURE,STRING].item_mem*/
  810. /*No:DICTIONARY[RUN_FEATURE,STRING].chain*/
  811. /*No:DICTIONARY[RUN_FEATURE,STRING].buckets*/
  812. /*No:DICTIONARY[RUN_FEATURE,STRING].keys*/
  813. int r199has(T199* C,T0* a1){
  814. int R=0;
  815. /*IF*/if ((((((T199*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  816. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T199*)C))->_modulus/*20*/)]/*)*/;
  817. while (!((((((T199*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  818. C->_has_mem=r429item(((T429*)((((T199*)C))->_chain/*12*/)),(((T199*)C))->_has_mem/*24*/);
  819. }
  820. }
  821. /*FI*/R=((((T199*)C))->_has_mem/*24*/)!=(0);
  822. return R;
  823. }
  824. /*No:DICTIONARY[RUN_FEATURE,STRING].Min_size*/
  825. /*No:DICTIONARY[RUN_FEATURE,STRING].store*/
  826. void r199with_capacity(T199* C,int a1){
  827. int _i=0;
  828. _i=32;
  829. while (!((_i)>=(a1))) {
  830. _i=(2)*(_i);
  831. }
  832. C->_modulus=(2)*(_i);
  833. {T226*n=malloc(sizeof(*n));
  834. *n=M226;
  835. r226make(n,(((T199*)C))->_modulus/*20*/);
  836. C->_buckets=(T0*)n;
  837. }
  838. {T429*n=malloc(sizeof(*n));
  839. *n=M429;
  840. r429make(n,1,_i);
  841. C->_chain=(T0*)n;
  842. }
  843. {T477*n=malloc(sizeof(*n));
  844. *n=M477;
  845. r477make(n,1,_i);
  846. C->_store=(T0*)n;
  847. }
  848. {T52*n=malloc(sizeof(*n));
  849. *n=M52;
  850. r52make(n,1,_i);
  851. C->_keys=(T0*)n;
  852. }
  853. r199initialize(C);
  854. }
  855. void r199put(T199* C,T0* a1,T0* a2){
  856. int _hash=0;
  857. _hash=(r7hash_code(((T7*)a2)))%((((T199*)C))->_modulus/*20*/);
  858. /*IF*/if ((((((T199*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  859. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  860. while (!((((((T199*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  861. C->_has_mem=r429item(((T429*)((((T199*)C))->_chain/*12*/)),(((T199*)C))->_has_mem/*24*/);
  862. }
  863. /*IF*/if (((((T199*)C))->_has_mem/*24*/)==(0)) {
  864. /*IF*/if (((((T199*)C))->_count/*32*/)>=(r477count(((T477*)((((T199*)C))->_store/*4*/))))) {
  865. r199expand(C);
  866. }
  867. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T199*)C))->_keys/*0*/));
  868. T0* b1=a2;
  869. int b2=(((T199*)C))->_free/*16*/;
  870. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  871. }/*]*/
  872. /*[IRF3.6put*/{T477* C1=((T477*)((((T199*)C))->_store/*4*/));
  873. T0* b1=a1;
  874. int b2=(((T199*)C))->_free/*16*/;
  875. ((((T477*)C1))->_storage/*0*/)[(b2)-((((T477*)C1))->_lower/*12*/)]=(b1);
  876. }/*]*/
  877. C->_has_mem=(((T199*)C))->_free/*16*/;
  878. C->_free=r429item(((T429*)((((T199*)C))->_chain/*12*/)),(((T199*)C))->_free/*16*/);
  879. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  880. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  881. int b2=(((T199*)C))->_has_mem/*24*/;
  882. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  883. }/*]*/
  884. /*[IRF3.5put*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T199*)C))->_has_mem/*24*/);
  885. /*]*/
  886. C->_count=((((T199*)C))->_count/*32*/)+(1);
  887. /*IF*/if (((((T199*)C))->_count/*32*/)>(((((T199*)C))->_modulus/*20*/)*(2))) {
  888. r199resize(C,(2)*((((T199*)C))->_modulus/*20*/));
  889. }
  890. /*FI*/}
  891. /*FI*/}
  892. else {
  893. /*[IRF3.6put*/{T477* C1=((T477*)((((T199*)C))->_store/*4*/));
  894. T0* b1=a1;
  895. int b2=(((T199*)C))->_has_mem/*24*/;
  896. ((((T477*)C1))->_storage/*0*/)[(b2)-((((T477*)C1))->_lower/*12*/)]=(b1);
  897. }/*]*/
  898. }
  899. /*FI*/C->_item_mem=0;
  900. }
  901. /*No:DICTIONARY[RUN_FEATURE,STRING].modulus*/
  902. /*No:DICTIONARY[RUN_FEATURE,STRING].count*/
  903. /*No:DICTIONARY[RUN_FEATURE,STRING].has_mem*/
  904. void r199initialize(T199* C){
  905. int _i=0;
  906. C->_count=0;
  907. C->_free=1;
  908. C->_has_mem=0;
  909. C->_item_mem=0;
  910. _i=1;
  911. while (!((_i)==(r429count(((T429*)((((T199*)C))->_chain/*12*/)))))) {
  912. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  913. int b1=(_i)+(1);
  914. int b2=_i;
  915. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  916. }/*]*/
  917. _i=(_i)+(1);
  918. }
  919. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  920. int b1=0;
  921. int b2=_i;
  922. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  923. }/*]*/
  924. _i=0;
  925. while (!((_i)>=((((T199*)C))->_modulus/*20*/))) {
  926. /*[IRF3.5put*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  927. /*]*/
  928. _i=(_i)+(1);
  929. }
  930. }
  931. T0* r718at(T718* C,T0* a1){
  932. T0* R=NULL;
  933. int _foo=0;
  934. _foo=r718has(C,a1);
  935. R=r863item(((T863*)((((T718*)C))->_store/*4*/)),(((T718*)C))->_has_mem/*24*/);
  936. return R;
  937. }
  938. void r718expand(T718* C){
  939. int _old_size=0;
  940. int _i=0;
  941. C->_item_mem=0;
  942. _old_size=r863count(((T863*)((((T718*)C))->_store/*4*/)));
  943. r429resize(((T429*)((((T718*)C))->_chain/*12*/)),1,(2)*(_old_size));
  944. r52resize(((T52*)((((T718*)C))->_keys/*0*/)),1,(2)*(_old_size));
  945. r863resize(((T863*)((((T718*)C))->_store/*4*/)),1,(2)*(_old_size));
  946. _i=(_old_size)+(1);
  947. while (!((_i)==(r429count(((T429*)((((T718*)C))->_chain/*12*/)))))) {
  948. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  949. int b1=(_i)+(1);
  950. int b2=_i;
  951. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  952. }/*]*/
  953. _i=(_i)+(1);
  954. }
  955. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  956. int b1=(((T718*)C))->_free/*16*/;
  957. int b2=_i;
  958. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  959. }/*]*/
  960. C->_free=(_old_size)+(1);
  961. }
  962. /*No:DICTIONARY[BASE_CLASS,STRING].free*/
  963. void r718make(T718* C){
  964. C->_modulus=(2)*(32);
  965. {T226*n=malloc(sizeof(*n));
  966. *n=M226;
  967. r226make(n,(((T718*)C))->_modulus/*20*/);
  968. C->_buckets=(T0*)n;
  969. }
  970. {T429*n=malloc(sizeof(*n));
  971. *n=M429;
  972. r429make(n,1,32);
  973. C->_chain=(T0*)n;
  974. }
  975. {T863*n=malloc(sizeof(*n));
  976. *n=M863;
  977. r863make(n,1,32);
  978. C->_store=(T0*)n;
  979. }
  980. {T52*n=malloc(sizeof(*n));
  981. *n=M52;
  982. r52make(n,1,32);
  983. C->_keys=(T0*)n;
  984. }
  985. r718initialize(C);
  986. }
  987. void r718remove(T718* C,T0* a1){
  988. int _p=0;
  989. int _n=0;
  990. int _hash=0;
  991. _hash=(r7hash_code(((T7*)a1)))%((((T718*)C))->_modulus/*20*/);
  992. _n=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  993. while (!(((_n)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T718*)C))->_keys/*0*/)),_n))))) {
  994. _p=_n;
  995. _n=r429item(((T429*)((((T718*)C))->_chain/*12*/)),_n);
  996. }
  997. /*IF*/if ((_n)!=(0)) {
  998. /*IF*/if ((_p)!=(0)) {
  999. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  1000. int b1=r429item(((T429*)((((T718*)C))->_chain/*12*/)),_n);
  1001. int b2=_p;
  1002. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1003. }/*]*/
  1004. }
  1005. else {
  1006. /*[IRF3.5put*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(r429item(((T429*)((((T718*)C))->_chain/*12*/)),_n));
  1007. /*]*/
  1008. }
  1009. /*FI*//*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  1010. int b1=(((T718*)C))->_free/*16*/;
  1011. int b2=_n;
  1012. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1013. }/*]*/
  1014. C->_free=_n;
  1015. C->_count=((((T718*)C))->_count/*32*/)-(1);
  1016. /*IF*/if ((_n)==((((T718*)C))->_has_mem/*24*/)) {
  1017. C->_has_mem=0;
  1018. }
  1019. /*FI*//*IF*/if ((((((T718*)C))->_count/*32*/)<((r863count(((T863*)((((T718*)C))->_store/*4*/))))/(4)))&&(((((T718*)C))->_count/*32*/)>(32))) {
  1020. r718shrink(C);
  1021. }
  1022. /*FI*/}
  1023. /*FI*/C->_item_mem=0;
  1024. }
  1025. void r718shrink(T718* C){
  1026. int _k=0;
  1027. int _j=0;
  1028. int _i=0;
  1029. T0* _chn=NULL;
  1030. T0* _kys=NULL;
  1031. T0* _str=NULL;
  1032. {T52*n=malloc(sizeof(*n));
  1033. *n=M52;
  1034. r52make(n,1,(r863count(((T863*)((((T718*)C))->_store/*4*/))))/(2));
  1035. _kys=(T0*)n;
  1036. }
  1037. {T863*n=malloc(sizeof(*n));
  1038. *n=M863;
  1039. r863make(n,1,(r863count(((T863*)((((T718*)C))->_store/*4*/))))/(2));
  1040. _str=(T0*)n;
  1041. }
  1042. {T429*n=malloc(sizeof(*n));
  1043. *n=M429;
  1044. r429make(n,1,(r863count(((T863*)((((T718*)C))->_store/*4*/))))/(2));
  1045. _chn=(T0*)n;
  1046. }
  1047. _i=1;
  1048. _j=0;
  1049. while (!((_j)>=((((T718*)C))->_modulus/*20*/))) {
  1050. _k=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_j]/*)*/;
  1051. /*IF*/if ((_k)!=(0)) {
  1052. /*[IRF3.5put*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_j]=(_i);
  1053. /*]*/
  1054. }
  1055. /*FI*/while (!((_k)==(0))) {
  1056. /*[IRF3.6put*/{T52* C1=((T52*)_kys);
  1057. T0* b1=r52item(((T52*)((((T718*)C))->_keys/*0*/)),_k);
  1058. int b2=_i;
  1059. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  1060. }/*]*/
  1061. /*[IRF3.6put*/{T863* C1=((T863*)_str);
  1062. T0* b1=r863item(((T863*)((((T718*)C))->_store/*4*/)),_k);
  1063. int b2=_i;
  1064. ((((T863*)C1))->_storage/*0*/)[(b2)-((((T863*)C1))->_lower/*12*/)]=(b1);
  1065. }/*]*/
  1066. _k=r429item(((T429*)((((T718*)C))->_chain/*12*/)),_k);
  1067. /*IF*/if ((_k)==(0)) {
  1068. /*[IRF3.6put*/{T429* C1=((T429*)_chn);
  1069. int b1=0;
  1070. int b2=_i;
  1071. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1072. }/*]*/
  1073. }
  1074. else {
  1075. /*[IRF3.6put*/{T429* C1=((T429*)_chn);
  1076. int b1=(_i)+(1);
  1077. int b2=_i;
  1078. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1079. }/*]*/
  1080. }
  1081. /*FI*/_i=(_i)+(1);
  1082. }
  1083. _j=(_j)+(1);
  1084. }
  1085. _i=((((T718*)C))->_count/*32*/)+(1);
  1086. while (!((_i)>=(r429count(((T429*)_chn))))) {
  1087. /*[IRF3.6put*/{T429* C1=((T429*)_chn);
  1088. int b1=(_i)+(1);
  1089. int b2=_i;
  1090. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1091. }/*]*/
  1092. _i=(_i)+(1);
  1093. }
  1094. /*[IRF3.6put*/{T429* C1=((T429*)_chn);
  1095. int b1=0;
  1096. int b2=_i;
  1097. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1098. }/*]*/
  1099. C->_free=((((T718*)C))->_count/*32*/)+(1);
  1100. C->_chain=_chn;
  1101. C->_keys=_kys;
  1102. C->_store=_str;
  1103. C->_item_mem=0;
  1104. }
  1105. void r718resize(T718* C,int a1){
  1106. int _p=0;
  1107. int _n=0;
  1108. int _i=0;
  1109. int _hash=0;
  1110. r226copy(((T226*)(oBC672tmp_buckets)),(((T718*)C))->_buckets/*8*/);
  1111. r226make(((T226*)((((T718*)C))->_buckets/*8*/)),a1);
  1112. _i=0;
  1113. while (!((_i)>=((((T718*)C))->_modulus/*20*/))) {
  1114. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  1115. while (!((_n)==(0))) {
  1116. _p=r429item(((T429*)((((T718*)C))->_chain/*12*/)),_n);
  1117. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T718*)C))->_keys/*0*/)),_n)))))%(a1);
  1118. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  1119. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  1120. int b2=_n;
  1121. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1122. }/*]*/
  1123. /*[IRF3.5put*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  1124. /*]*/
  1125. _n=_p;
  1126. }
  1127. _i=(_i)+(1);
  1128. }
  1129. C->_modulus=a1;
  1130. C->_item_mem=0;
  1131. }
  1132. /*No:DICTIONARY[BASE_CLASS,STRING].item_mem*/
  1133. /*No:DICTIONARY[BASE_CLASS,STRING].chain*/
  1134. /*No:DICTIONARY[BASE_CLASS,STRING].keys*/
  1135. /*No:DICTIONARY[BASE_CLASS,STRING].buckets*/
  1136. int r718has(T718* C,T0* a1){
  1137. int R=0;
  1138. /*IF*/if ((((((T718*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  1139. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T718*)C))->_modulus/*20*/)]/*)*/;
  1140. while (!((((((T718*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  1141. C->_has_mem=r429item(((T429*)((((T718*)C))->_chain/*12*/)),(((T718*)C))->_has_mem/*24*/);
  1142. }
  1143. }
  1144. /*FI*/R=((((T718*)C))->_has_mem/*24*/)!=(0);
  1145. return R;
  1146. }
  1147. /*No:DICTIONARY[BASE_CLASS,STRING].Min_size*/
  1148. /*No:DICTIONARY[BASE_CLASS,STRING].store*/
  1149. void r718put(T718* C,T0* a1,T0* a2){
  1150. int _hash=0;
  1151. _hash=(r7hash_code(((T7*)a2)))%((((T718*)C))->_modulus/*20*/);
  1152. /*IF*/if ((((((T718*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  1153. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  1154. while (!((((((T718*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  1155. C->_has_mem=r429item(((T429*)((((T718*)C))->_chain/*12*/)),(((T718*)C))->_has_mem/*24*/);
  1156. }
  1157. /*IF*/if (((((T718*)C))->_has_mem/*24*/)==(0)) {
  1158. /*IF*/if (((((T718*)C))->_count/*32*/)>=(r863count(((T863*)((((T718*)C))->_store/*4*/))))) {
  1159. r718expand(C);
  1160. }
  1161. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T718*)C))->_keys/*0*/));
  1162. T0* b1=a2;
  1163. int b2=(((T718*)C))->_free/*16*/;
  1164. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  1165. }/*]*/
  1166. /*[IRF3.6put*/{T863* C1=((T863*)((((T718*)C))->_store/*4*/));
  1167. T0* b1=a1;
  1168. int b2=(((T718*)C))->_free/*16*/;
  1169. ((((T863*)C1))->_storage/*0*/)[(b2)-((((T863*)C1))->_lower/*12*/)]=(b1);
  1170. }/*]*/
  1171. C->_has_mem=(((T718*)C))->_free/*16*/;
  1172. C->_free=r429item(((T429*)((((T718*)C))->_chain/*12*/)),(((T718*)C))->_free/*16*/);
  1173. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  1174. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  1175. int b2=(((T718*)C))->_has_mem/*24*/;
  1176. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1177. }/*]*/
  1178. /*[IRF3.5put*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T718*)C))->_has_mem/*24*/);
  1179. /*]*/
  1180. C->_count=((((T718*)C))->_count/*32*/)+(1);
  1181. /*IF*/if (((((T718*)C))->_count/*32*/)>(((((T718*)C))->_modulus/*20*/)*(2))) {
  1182. r718resize(C,(2)*((((T718*)C))->_modulus/*20*/));
  1183. }
  1184. /*FI*/}
  1185. /*FI*/}
  1186. else {
  1187. /*[IRF3.6put*/{T863* C1=((T863*)((((T718*)C))->_store/*4*/));
  1188. T0* b1=a1;
  1189. int b2=(((T718*)C))->_has_mem/*24*/;
  1190. ((((T863*)C1))->_storage/*0*/)[(b2)-((((T863*)C1))->_lower/*12*/)]=(b1);
  1191. }/*]*/
  1192. }
  1193. /*FI*/C->_item_mem=0;
  1194. }
  1195. /*No:DICTIONARY[BASE_CLASS,STRING].modulus*/
  1196. /*No:DICTIONARY[BASE_CLASS,STRING].count*/
  1197. /*No:DICTIONARY[BASE_CLASS,STRING].has_mem*/
  1198. void r718initialize(T718* C){
  1199. int _i=0;
  1200. C->_count=0;
  1201. C->_free=1;
  1202. C->_has_mem=0;
  1203. C->_item_mem=0;
  1204. _i=1;
  1205. while (!((_i)==(r429count(((T429*)((((T718*)C))->_chain/*12*/)))))) {
  1206. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  1207. int b1=(_i)+(1);
  1208. int b2=_i;
  1209. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1210. }/*]*/
  1211. _i=(_i)+(1);
  1212. }
  1213. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  1214. int b1=0;
  1215. int b2=_i;
  1216. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1217. }/*]*/
  1218. _i=0;
  1219. while (!((_i)>=((((T718*)C))->_modulus/*20*/))) {
  1220. /*[IRF3.5put*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  1221. /*]*/
  1222. _i=(_i)+(1);
  1223. }
  1224. }
  1225.  
  1226.